package com.atguigu.juc;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;

/*
 * 一、线程池：提供一个线程队列，队列中保存着所有等待状态的线程，避免了线程创建和销毁的额外开销， 提高了响应的速度
 *
 * 二、线程池的体系结构
 *    java.util.concurrent.Executor：负责线程的使用和调度的根接口
 *         |--**ExecutorService 子接口：线程池的主要接口
 *             |--ThreadPoolExecutor 线程池实现类
 *             |--ScheduledExecutorService 子接口，负责线程的调度
 *                  |--ScheduledThreadPoolExecutor 继承ThreadPoolExecutor，实现ScheduledExecutorService接口
 * 三、工具类：Executors
 * ExecutorService newFixedThreadPool()：创建固定大小的线程池
 * ExecutorService newCachedThreadPool()：缓存线程池，线程池的大小不固定，可以根据需求自动地更改数量
 * ExecutorService newSingleThreadExecutor()：创建单个线程池，线程池中只有一个线程
 *
 * ScheduledExecutorService newScheduledThreadPool(int corePoolSize) ： 创建固定大小的线程池，可以延迟或定时执行任务
 */
public class TestThreadPool {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ExecutorService pool = Executors.newFixedThreadPool(10);

//        pool.submit(new ThreadPoolDemo());
//
//        // 关闭线程池
//        pool.shutdown();

        List<Future> list = new ArrayList<>();
        Map<Integer, Future> map = new HashMap<>();
        for (int i = 0; i < 10; i++) {
            Future<Integer> future = pool.submit(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    int sum = 0;
                    for (int i = 0; i <= 10; i++) {
                        sum += i;
                    }
                    System.out.println(Thread.currentThread().getName() + "：计算中");
                    Thread.sleep(1000);
                    return sum;
                }
            });

            System.out.println(Thread.currentThread().getName() + " : " + future.get()); // future.get()会阻塞

            list.add(future);
            map.put(i, future);
        }

//        for (Future futureTask : list) {
//            System.out.println(futureTask.get());
//        }

        for (Integer key : map.keySet()) {
            Future future = map.get(key);
            System.out.println(key + "----------------" + future.get());
        }


    }
}

class ThreadPoolDemo implements Runnable {

    private int i = 0;

    @Override
    public void run() {
        while (i < 100) {
            System.out.println(Thread.currentThread().getName() + " : " + ++i);
        }
    }
}
